#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;

const int INF = (int)1e9;
const int pow2 = (1 << 19);
const int N = (int)4e5 + 100;

struct SegmentTree
{
	int tree[pow2 * 2];
	int d[pow2 * 2];
	void build ()
	{
		memset(tree, 0, sizeof(tree));
		memset(d, 0, sizeof(d));
	}
	void push(int v)
	{
		tree[2 * v] += d[v];
		d[2 * v] += d[v];
		
		tree[2 * v + 1] += d[v];
		d[2 * v + 1] += d[v];

		d[v] = 0;
	}
	void addVal(int a, int b, int val, int v = 1, int l = 0, int r = pow2 - 1)
	{
		if (l >= a && r <= b)
		{
			tree[v] += val;
			d[v] += val;
			return;
		}
		if (l > b || r < a)
			return;
		push(v);
		int m = (l + r) / 2;
		addVal(a, b, val, 2 * v, l, m);
		addVal(a, b, val, 2 * v + 1, m + 1, r);
		tree[v] = min(tree[2 * v], tree[2 * v + 1]);
	}
	int getMin(int a, int b, int v = 1, int l = 0, int r = pow2 - 1)
	{
		if (l >= a && r <= b)
			return tree[v];
		if (l > b || r < a)
			return INF;
		push(v);
		int m = (l + r) / 2;
		return min(getMin(a, b, 2 * v, l, m), getMin(a, b, 2 * v + 1, m + 1, r));
	}
	int getMinRoot()
	{
		return tree[1];
	}
} tree;

vector <int> listSegment[N];
int listCoords[N];
int l[N], r[N];
int indC = 0;

int getIndex(int coord)
{
	return lower_bound(listCoords, listCoords + indC, coord) - listCoords;
}

void addSegment(int a, int b)
{
	a = getIndex(a);
	b = getIndex(b);
	listSegment[a].push_back(b);
	tree.addVal(b, indC - 1, -1);
}

int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		tree.build();
		int n, m;
		scanf("%d%d", &m, &n);
		for (int i = 0; i < n; i++)
		{
			scanf("%d%d", &l[i], &r[i]);
		}
		if (n > m)
		{
			puts("NO");
			continue;
		}
		indC = 0;
		for (int i = 0; i < n; i++)
		{
			listCoords[indC++] = l[i];
			listCoords[indC++] = r[i] + 1;
		}
		listCoords[indC++] = 0;
		sort(listCoords, listCoords + indC);
		indC = unique(listCoords, listCoords + indC) - listCoords;
		for (int i = indC; i < 2 * indC; i++)
			listCoords[i] = listCoords[i - indC] + m;
		indC *= 2;

		for (int i = 0; i < indC; i++)
			listSegment[i].clear();

		for (int i = 0; i < indC; i++)
			tree.addVal(i, i, listCoords[i]);
		for (int i = 0; i < n; i++)
		{
			if (l[i] <= r[i])
			{
				addSegment(l[i], r[i] + 1);
				addSegment(l[i] + m, r[i] + 1 + m);
			}
			else
				addSegment(l[i], r[i] + m + 1);
		}

		bool ok = true;
		for (int i = 0; i < indC; i++)
		{
			if (tree.getMinRoot() < 0)
			{
				ok = false;
				break;
			}
			tree.addVal(i + 1, indC - 1, -(listCoords[i + 1] - listCoords[i]));
			for (int s = 0; s < (int)listSegment[i].size(); s++)
			{
				int b = listSegment[i][s];
				tree.addVal(b, indC - 1, 1);
			}
		}
		if (ok)
			puts("YES");
		else
			puts("NO");
	}
	return 0;
}